// 基础URL，所有请求的前缀
const BASE_URL = "https://www.zhibott.com/prod-api";
//const BASE_URL = "http://localhost:9001/dev-api"
// 请求超时时间，单位毫秒
const REQUEST_TIMEOUT = 60000;

// 用于存储待处理的请求（处理重复请求和取消请求）
let pendingRequests = {};

/**
 * 获取token的方法
 * 例如，从本地存储或vuex中获取
 */
function getToken() {
	return uni.getStorageSync("token") || null;
}

/**
 * 移除待处理的请求
 * 主要用于处理重复的请求和取消请求
 * @param {Object} config - 请求配置
 */
// 如发起了一个GET请求
// request.get("/api/data");
// 随后决定取消这个请求
// removePendingRequest({ method: "GET", url: "/api/data" });

function removePendingRequest(config) {
	const requestIdentifier = `${config.method}${config.url}`;
	if (pendingRequests[requestIdentifier]) {
		const {
			task
		} = pendingRequests[requestIdentifier];
		task.abort();
		delete pendingRequests[requestIdentifier];
	}
}

// 请求与响应拦截
/**
 * 全局请求拦截器
 * 可以用于修改请求配置，如添加请求头等
 * @param {Object} config - 请求配置
 * @return {Object} - 返回修改后的请求配置
 */
function requestInterceptor(config) {
	let token = getToken();
	if(token == null){
		return config;
		/* uni.reLaunch({
			url: '/minePages/regist'
		}); */
	}else{
		config.header.Authorization = "Bearer " + getToken();
		return config;
	}
}

/**
 * 全局响应拦截器
 * 可以用于处理特定的响应，如根据状态码进行重定向等
 * @param {Object} response - 响应对象
 * @return {Object} - 返回处理后的响应对象
 */
function responseInterceptor(response) {

	if (response.data.code === 401) {
		// 未授权处理
		uni.reLaunch({
			url: '/minePages/regist'
		});
	}
	if (response.data.code === 403) {
		// 未授权处理
		uni.showModal({
			title: '提示：',
			content: "暂无操作权限",
			success: function(res) {
				if (res.confirm) {
					uni.reLaunch({
						url: '/pages/index'
					});
				}
			}
		});

	}
	return response;
}
// 封装的请求方法
export default {
	/**
	 * 封装的网络请求方法
	 * @param {Object} options - 请求选项
	 * @return {Promise} - 返回一个Promise对象
	 */
	request(options) {
		return new Promise((resolve, reject) => {
			const finalOptions = {
				...options,
				url: BASE_URL + options.url,
				timeout: REQUEST_TIMEOUT,
				header: {
					"Content-Type": "application/json",
					...options.header
				}
			};
			// 使用请求拦截器
			const interceptedOptions = requestInterceptor(finalOptions);
			// 取消重复的请求
			removePendingRequest(interceptedOptions);
			const requestTask = uni.request({
				...interceptedOptions,
				success: (response) => {
					// 使用响应拦截器
					const interceptedResponse = responseInterceptor(response);
					if (interceptedResponse.statusCode >= 200 && interceptedResponse.statusCode <
						300) {
						resolve(interceptedResponse.data);
					} else {
						reject(interceptedResponse);
					}
				},
				fail: (error) => {
					if (error.errMsg !== 'request:fail abort') {
						reject(error);
					}

				},
				complete: () => {
					removePendingRequest(interceptedOptions);
				}
			});

			// 存储此次请求任务，以供后续处理
			const requestIdentifier = `${interceptedOptions.method}${interceptedOptions.url}`;
			pendingRequests[requestIdentifier] = {
				cancel: reject,
				task: requestTask
			};
		});
	},

	/**
	 * 封装的GET请求方法
	 * @param {string} url - 请求的URL
	 * @param {Object} params - 请求参数
	 * @param {Object} options - 其他选项
	 * @return {Promise} - 返回一个Promise对象
	 */
	get(url, params = {}, options = {}) {
		return this.request({
			method: "GET",
			url,
			data: params,
			...options
		});
	},

	/**
	 * 封装的POST请求方法
	 * @param {string} url - 请求的URL
	 * @param {Object} data - 请求数据
	 * @param {Object} options - 其他选项
	 * @return {Promise} - 返回一个Promise对象
	 */
	post(url, data, options = {}) {
		return this.request({
			method: "POST",
			url,
			data,
			...options
		});
	},

	getBaseUrl() {
		return BASE_URL;
	},

	getUpload() {
		return BASE_URL + "/common/upload";
	},
	
	getAccessToken() {
		this.get("/WxOpenApi/getAccessToken").then((res) => {
			return res.msg;
		});
	},
	
	updateUser(userId) {
		this.get("/system/user/getUserInfo/"+userId).then((res) => {
			console.log(res)
			uni.removeStorageSync("userinfo");
			uni.setStorageSync("userinfo", res.data)
		});
	},

	loginOut() {
		uni.removeStorageSync("userinfo");
		uni.removeStorageSync("token");
		uni.reLaunch({
			url: '/pages/index'
		});
	}
};

// 调用方法
/*
login() {
    try {
        return request.get("posts", { param1: "value1" });
    } catch (error) {
        console.error("请求错误：", error);
    }
}
*/